﻿#include "include_commobj_header.h"
#include "util/fne.h"
#include "bstring/bstrlib.h"
#include "util/vector.hpp"

// 本命令被隐藏, 原始名字 = "构造函数", 本命令为构造函数
// 调用格式: _SDT_NULL (快速字节集对象).构造函数, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_Constructor_80_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self = new CBString{};
}

// 本命令被隐藏, 原始名字 = "复制构造函数", 本命令为复制构造函数
// 调用格式: _SDT_NULL (快速字节集对象).复制构造函数, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_CopyConstructor_81_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto& rht = fne::args_to_other<CBString>(pArgInf);
	self = new CBString{*rht};
}

// 本命令被隐藏, 原始名字 = "析构函数", 本命令为析构函数
// 调用格式: _SDT_NULL (快速字节集对象).析构函数, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_Destructor_82_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	if (self)
	{
		self->CBString::~CBString();
		operator delete(self);
	}
	self = nullptr;
}

// 调用格式: SDT_INT (快速字节集对象).取长度, 命令说明: "单位为字节(byte)"
// 无参数
COMMOBJ_EXTERN_C void commobj_GetLength_83_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	pRetData->m_int = self->length();
}

// 调用格式: SDT_BIN (快速字节集对象).取字节集, 命令说明: "取本对象中的全部或部分字节集。"
// 参数<1>: [起始位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。如果本参数被省略，默认为1。"
// 参数<2>: [字节数 SDT_INT], 参数说明: "如果本参数被省略，默认为从“起始位置”到字节集结尾的字节数。"
COMMOBJ_EXTERN_C void commobj_GetData_84_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[1].empty())
	{
		if (arg1 < 0)
			start = self->length() + arg1;
		if (arg1 > 0)
			start = arg1 - 1;
	}

	if (start >= self->length())
	{
		pRetData->m_pBin = fne::clone_bin(self->data, 0);
		return;
	}

	auto len = self->length() - start;

	if (!pArgInf[2].empty() && arg2 >= 0)
	{
		len = min(len, arg2);
	}

	pRetData->m_pBin = fne::clone_bin(reinterpret_cast<char*>(self->data) + start, len);
}

// 调用格式: SDT_BOOL (快速字节集对象).置字节集, 命令说明: NULL
// 参数<1>: 数据 数组/非数组 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型及其数组数据。"
COMMOBJ_EXTERN_C void commobj_SetData_85_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->trunc(0);
	for (int i = 0; i < nArgCount; ++i)
	{
		fne::append_to_binary(&pArgInf[i + 1], *self);
	}
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速字节集对象).清除字节集, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_Empty_86_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->trunc(0);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速字节集对象).添加, 命令说明: NULL
// 参数<1>: 欲添加的数据 数组/非数组 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型及其数组数据。"
COMMOBJ_EXTERN_C void commobj_Append_87_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	for (int i = 0; i < nArgCount; ++i)
	{
		fne::append_to_binary(&pArgInf[i + 1], *self);
	}
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速字节集对象).插入, 命令说明: "在指定的插入位置之前插入指定的字节集数据"
// 参数<1>: 插入位置 SDT_INT, 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。"
// 参数<2>: 欲插入的数据 数组/非数组 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型及其数组数据。"
COMMOBJ_EXTERN_C void commobj_Insert_88_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	//void* arg2 = pArgInf[2].m_pAryData;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[1].empty())
	{
		if (arg1 < 0)
			start = self->length() + arg1;
		if (arg1 > 0)
			start = arg1 - 1;
	}
	CBString insert_bin;
	for (int i = 0; i < nArgCount -1; ++i)
	{
		fne::append_to_binary(&pArgInf[i + 2], insert_bin);
	}
	self->insert(start, insert_bin);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速字节集对象).删除字节, 命令说明: "删除字节集中从指定字节开始的指定个数的字节（包括起始删除位置处的字节）"
// 参数<1>: 起始删除位置 SDT_INT, 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。"
// 参数<2>: 欲删除的字节数 SDT_INT, 参数说明: NULL
COMMOBJ_EXTERN_C void commobj_DeleteBytes_89_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (arg1 < 0)
		start = self->length() + arg1;
	if (arg1 > 0)
		start = arg1 - 1;
	auto len = arg2;
	if (arg2 < 0)
		len = self->length() - start;
	self->remove(start, len);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BYTE (快速字节集对象).取字节, 命令说明: "取指定位置处的字节值。"
// 参数<1>: 位置索引 SDT_INT, 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。"
COMMOBJ_EXTERN_C void commobj_GetByte_90_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg1 = pArgInf[1].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (arg1 < 0)
		start = self->length() + arg1;
	if (arg1 > 0)
		start = arg1 - 1;
	pRetData->m_byte = self->data[start];
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_91, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__91_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_92, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__92_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_93, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__93_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 调用格式: SDT_INT (快速字节集对象).寻找字节集, 命令说明: "寻找指定数据在本对象数据中从“起始寻找位置”开始第一次出现时的位置索引，未找到则返回-1。"
// 参数<1>: 欲寻找的数据 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型。"
// 参数<2>: [起始寻找位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。如果本参数被省略，默认为1。"
COMMOBJ_EXTERN_C void commobj_Find_94_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[2].empty())
	{
		if (arg2 < 0)
			start = self->length() + arg2;
		if (arg2 > 0)
			start = arg2 - 1;
	}
	const int res = self->find(fne::to_binary(&pArgInf[1]), start);
	pRetData->m_int = res < 0 ? res : res + 1;
}

// 调用格式: SDT_INT (快速字节集对象).倒找字节集, 命令说明: "在本对象数据中从“起始寻找位置”开始向数据开头方向寻找指定数据第一次出现时的位置索引（相对数据开头），未找到则返回-1。"
// 参数<1>: 欲寻找的数据 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型。"
// 参数<2>: [起始寻找位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。默认为-1，即从数据结尾开始向前寻找。"
COMMOBJ_EXTERN_C void commobj_FindReverse_95_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = self->length() - 1;
	if (!pArgInf[2].empty())
	{
		if (arg2 < 0)
			start = self->length() + arg2;
		if (arg2 > 0)
			start = arg2 - 1;
	}
	const int res = self->reversefind(fne::to_binary(&pArgInf[1]), start);
	pRetData->m_int = res < 0 ? res : res + 1;
}

// 调用格式: SDT_BOOL (快速字节集对象).替换字节集, 命令说明: "将本对象数据中从指定位置开始指定长度的数据替换为新的数据。"
// 参数<1>: 起始替换位置 SDT_INT, 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。"
// 参数<2>: 替换长度 SDT_INT, 参数说明: NULL
// 参数<3>: [替换为字节集 _SDT_ALL], 参数说明: "参数类型支持各种基本数据类型。如果本参数被省略，则删除字节集中的指定部分。"
COMMOBJ_EXTERN_C void commobj_ReplaceBin_96_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (arg1 < 0)
		start = self->length() + arg1;
	if (arg1 > 0)
		start = arg1 - 1;
	int len = arg2;
	if (arg2 < 0)
		len = self->length() - start;
	self->replace(start, len, pArgInf[3].empty() ? "" : fne::to_binary(&pArgInf[3]));
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_INT (快速字节集对象).替换子字节集, 命令说明: "在本对象数据中查找“被替换数据”，并将其替换为“替换为数据”。返回实际替换次数。"
// 参数<1>: 被替换数据 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型。"
// 参数<2>: [替换为数据 _SDT_ALL], 参数说明: "参数类型支持各种基本数据类型。如果本参数被省略，则表示将删除被替换数据。"
// 参数<3>: [起始替换位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字节，2表示第二个字节，依次类推；位置索引也可以为负值，-1表示最后一个字节，-2表示倒数第二个字节，依次类推。如果本参数被省略，默认为1。"
// 参数<4>: [最大替换次数 SDT_INT], 参数说明: "如果本参数被省略，或值为-1，表示不限制替换次数。"
COMMOBJ_EXTERN_C void commobj_ReplaceSubBin_97_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg3 = pArgInf[3].m_int;
	INT arg4 = pArgInf[4].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;

	if (!pArgInf[3].empty())
	{
		if (arg3 < 0)
			start = self->length() + arg3;
		if (arg3 > 0)
			start = arg3 - 1;
	}
	if (pArgInf[4].empty())
		arg4 = -1;

	auto count = 0;
	const auto sub_bin = fne::to_binary(&pArgInf[1]);
	CBString replace_bin;
	if (pArgInf[2].empty())
		replace_bin = "";
	else
		replace_bin = fne::to_binary(&pArgInf[2]);
	CBString ret{self->data, start};
	do
	{
		const auto pos = self->find(sub_bin, start);
		if (pos == -1)
			break;
		ret += CBStringView{self->data + start, pos - start};
		ret += replace_bin;
		start = pos + sub_bin.length();
		count++;
	}
	while (arg4 == -1 || count < arg4);
	if (start < self->length())
		ret += CBStringView{self->data + start, self->length() - start};
	*self = ret;
	pRetData->m_int = count;
}

// 调用格式: SDT_BIN (快速字节集对象).[]分割字节集, 命令说明: NULL
// 参数<1>: [用作分隔的字节集 SDT_BIN], 参数说明: "如果被省略，则默认使用字节 0 作为分隔符。如果是一个长度为零的文本，则返回的数组仅包含一个成员，其内容是本对象中的文本。"
// 参数<2>: [要返回的子文本数目 SDT_INT], 参数说明: "如果为-1，表示不限制替换次数。如果本参数被省略，默认为-1。"
COMMOBJ_EXTERN_C void commobj_SplitBinary_98_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	CBString split_bin;
	if (pArgInf[1].empty())
		split_bin = ",";
	else
		split_bin = fne::to_binary(&pArgInf[1]);
	if (pArgInf[2].empty())
		arg2 = -1;
	auto count = 0;
	util::vector<char*> res{};
	auto start = 0;
	do
	{
		const int pos = self->find(split_bin, start);
		if (pos == -1)
		{
			if (start != self->length())
				res.push(reinterpret_cast<char*>(fne::clone_bin(self->data + start, self->length() - start)));
			break;
		}
		res.push(reinterpret_cast<char*>(fne::clone_bin(self->data + start, pos - start)));
		start = pos + split_bin.length();
		count++;
	}
	while (arg2 == -1 || count < arg2);

	pRetData->m_pAryData = fne::copy_array<char*>(res.data(), res.length());
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_99, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__99_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_100, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__100_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_101, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__101_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_102, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__102_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_103, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__103_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_104, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__104_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_105, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__105_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_106, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__106_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_107, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__107_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_108, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__108_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_109, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__109_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_110, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__110_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_111, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__111_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_112, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__112_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_113, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__113_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_114, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__114_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_115, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__115_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_116, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__116_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_117, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__117_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_118, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__118_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_119, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__119_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_120, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__120_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_121, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__121_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_122, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__122_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_123, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__123_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_124, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__124_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_125, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__125_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 调用格式: SDT_BOOL (快速字节集对象).从文件读, 命令说明: "从指定的文件中读取其所有数据到本对象中。"
// 参数<1>: 文件名 SDT_TEXT, 参数说明: "请提供包含完整路径的文本名称。"
COMMOBJ_EXTERN_C void commobj_ReadFromFile_126_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto file = fopen(arg1, "rb");
	if (!file)
	{
		pRetData->m_bool = FALSE;
		return;
	}
	CBStream stream(reinterpret_cast<bNread>(fread), file);
	stream.read(*self);
	fclose(file);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速字节集对象).写到文件, 命令说明: "将本对象中的数据写入指定的文件中。如果该文件不存在，则自动创建；如果该文件已经存在，其原有内容将被直接覆盖！"
// 参数<1>: 文件名 SDT_TEXT, 参数说明: "请提供包含完整路径的文本名称。"
COMMOBJ_EXTERN_C void commobj_WriteToFile_127_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto file = fopen(arg1, "wb");
	if (!file)
	{
		pRetData->m_bool = FALSE;
		return;
	}
	fwrite(self->data, sizeof(char), self->length(), file);
	fclose(file);
	pRetData->m_bool = TRUE;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_128, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__128_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_129, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__129_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 调用格式: SDT_INT (快速字节集对象).取缓冲区, 命令说明: "返回指定大小的缓冲区内存首地址，该地址同时也是内部数据指针。如果不能获取足够大小的缓冲区，将返回0。可以向该缓冲区直接写入数据，注意写入数据时请不要写到缓冲区之外。如果改变了缓冲区中数据的长度，必须及时调用“释放缓冲区()”。"
// 参数<1>: [缓冲区大小 SDT_INT], 参数说明: "应大于零并小于“最大可用内存”。如果本参数被省略，默认为当前数据长度。"
COMMOBJ_EXTERN_C void commobj_GetBuffer_130_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg1 = pArgInf[1].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	pRetData->m_int = reinterpret_cast<INT>(self->data);
}

// 调用格式: SDT_BOOL (快速字节集对象).释放缓冲区, 命令说明: "告知对象“最新的、经外界修改过的”数据长度。另请参考“取缓冲区()”中的说明。"
// 参数<1>: 数据长度 SDT_INT, 参数说明: "经外界修改后的数据长度。"
COMMOBJ_EXTERN_C void commobj_ReleaseBuffer_131_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg1 = pArgInf[1].m_int;
}

// 调用格式: SDT_BOOL (快速字节集对象).置可用内存, 命令说明: "设置本对象内部使用的最小可用内存和最大可用内存。使用本方法可以优化内存使用，但因为内部已经有适当的初始值，普通用户不必调用本方法。"
// 参数<1>: [最小可用内存 SDT_INT], 参数说明: "单位为字节。如果本参数被省略，则保持现有“最小可用内存”数值不变。其内部初始值为10240字节，约10K。"
// 参数<2>: [最大可用内存 SDT_INT], 参数说明: "单位为字节。如果本参数被省略，则保持现有“最大可用内存”数值不变。其内部初始值为2147483647字节，约2G。"
COMMOBJ_EXTERN_C void commobj_SetMemLength_132_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->alloc(arg1);
}

// 调用格式: SDT_BOOL (快速字节集对象).置内存增量, 命令说明: "设置本对象内部使用的内存增量值。所谓“内存增量”，即每次需要申请内存时在原来的基础上增加的内存数量（多申请出来的内存可供后续操作使用，从而减少了申请内存的次数，提高了执行效率）。正确使用本方法可以优化内存使用并提高执行效率，但因为内部已经有适当的初始值，普通用户不必调用本方法。"
// 参数<1>: 内存增量 SDT_INT, 参数说明: "单位为字节。如果此值过小，可能导致数据操作效率降低；如果此值过大，可能导致消耗较多内存。内部初始值为10240字节，约10K。"
COMMOBJ_EXTERN_C void commobj_SetMemGrowSize_133_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg1 = pArgInf[1].m_int;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_134, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__134_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_135, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__135_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_136, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__136_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_137, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__137_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_138, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__138_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速字节集对象).无法识别的名字_139, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__139_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}
